/**
 * Crazy Table Http
 *  License by CrazyYi.
 *
 *  Only use for table http request and process
 *
 *  @version
 *  v1.0.0 20200206
 *  v1.1.0 20200228: 单独保存pkey
 *  v1.2.0 20200429: 新增当前是否是update操作的http请求
 *
 */
layui.define(['table', 'jquery', 'crazyTool'], function (exports) {
    const MOD_NAME = 'crazyHttp'

    const STR_CONN = ','
    const HTTP_CONN = '&'

    let table = layui.table, $ = layui.jquery,
        crazyTool = layui.crazyTool;

    // v1.1.0，单独设置如下参数
    const defaultSet = {
        pkey: {field: 'id', name: 'id'}, // v1.1.0，单独保存,主表的索引字段field，以及对应http请求的名称name
        mark: {
            strConn: ',', // 字符串 拼接字符（说明是数组），暂不支持修改
            arrConn: ',', // 转换成HTTP请求的数组拼接字符
            rangeConn: '~', // 范围拼接字符，说明该字段是范围，比如1~8
        }, // 数据参数字符
    };
    let gSet = {};

    // http config default
    const defaultOption = {
        update: {mode: 'local', url: '', method: 'get', where: {}, jump: false, success: '', error: ''},
        delete: {mode: 'local', url: '', method: 'get', where: {}, jump: false, success: '', error: ''},
        read: {mode: 'local', url: '', method: 'get', where: {}, jump: true, success: '', error: ''},
        create: {mode: 'local', url: '', method: 'get', where: {}, jump: true, success: '', error: ''},
    };
    let gOptions = {}; // http config
    const gHttp = {
        render: function (myTable) {
            $.extend(gOptions, defaultOption);
            $.extend(true, gOptions, myTable.httpConfig);

            $.extend(true, gSet, defaultSet, myTable.setting); // v1.1.0
        },
        options: function () {
            return gOptions;
        },
        update: function (where) {
            let u = gOptions.update;
            $.extend(u.where, where);
            this.ajax(u);
        },
        /**
         * 转换成我们需要的where 格式
         *  1、数组：用逗号分隔
         *  2、不存在：设置为空字符串
         *  3、范围：用~表示范围，常用于时间戳、数字等
         *  4、其他：模糊查找
         * @param where
         * @param update : boolean, 当前是否是更新操作
         */
        getHttpWhere: function (where, update = false) {
            let m = gSet.mark;

            // 将数组转字符串
            let new_where = {};
            $.each(where, function (key, item) {
                if ($.isArray(item)) {
                    new_where[key] = item.join(m.arrConn);
                    return true;
                } else if ((item + '').indexOf(m.arrConn) > 0) {
                    new_where[key] = item; // 包含, ，且是在中间的字符，属于数组，
                    return true;
                } else if ((item + '').indexOf(m.strConn) > 0) {
                    new_where[key] = (item + '').replaceAll(m.strConn, m.arrConn); // 包含|，属于数组。注意全局替换
                    return true;
                } else if (!item) {
                    new_where[key] = ''; // 当前字段设置为空
                    return true;
                } else if (crazyTool.isIntNum(item)) {
                    new_where[key] = item; // 如果是整数，则直接返回。整数暂不支持模糊查找
                    return true;
                } else if ((item + '').indexOf('~') > 0) {
                    new_where[key] = item; // 包含~，且是在中间的字符，属于范围，
                    return true;
                } else {
                    if (!!update) {
                        new_where[key] = item; // 如果当前是update，则这个需要调整为 精确修改
                    } else {
                        new_where[key] = '%' + item + '%'; // 改成模糊查找
                    }

                    return true;
                }
            });
            log.print('http req where => before =', where);
            log.print('http req where => after =', new_where);
            return new_where
        },
        /**
         * 将缓存中保存的JSON 数据 转换成 layui form 可用的 处理checkbox
         *
         * @returns {any | string}
         * @param params
         */
        /**
         * ajax 请求
         * @param params
         * @param update : boolean, 当前是否是更新操作
         */
        ajax: function (params, update = false) {
            let othis = this;
            let where = this.getHttpWhere(params.where, update);
            let success = params.success || false;
            let error = params.error || false;
            let obj = params.obj || false;
            let ajaxOptions = {
                url: params.url,
                data: where,
                type: params.method || 'get',
                dataType: 'json',
                success: function (res) {
                    if (success && typeof success === 'function') {
                        if (!res.code) {
                            success(res);
                            layer.msg('更新成功！' + res.msg);
                        } else {
                            layer.msg('很抱歉！出错了，' + res.msg);
                        }

                    } else {
                        if (!res.code) {
                            !!obj && obj.update(where);
                            layer.msg('更新成功！' + res.msg);
                        } else {
                            layer.msg('很抱歉！出错了，' + res.msg);
                        }
                    }
                },
                error: function (res) {
                    if (error && typeof error === 'function') {
                        error(res);
                    } else {
                        layer.msg('很抱歉！出错了，' + res.msg);
                    }
                }
            };

            $.ajax(ajaxOptions);
        },
        /**
         * 页面跳转
         * @param url
         * @param where
         * @param update : boolean, 当前是否是更新操作
         */
        href: function (url, where, update = false) {
            let param = '';
            where = this.getHttpWhere(where);
            if (where.constructor === Object) {
                param = this.httpGetParam(where, update);
                if (typeof (param) !== 'string') {
                    return; // 如果返回的不是字符串，则退出
                }
            } else if (typeof (where) !== 'string') {
                param = where;
            } else {
                param = '';
            }

            url = url + param;
            window.location.href = url;
        },
        /**
         *
         * @param http
         * @param update : boolean, 当前是否是更新操作
         */
        httpReq: function (http, update = false) {
            log.print('http request params:', http);
            if (http.jump) {
                this.href(http.url, http.where, update);
            } else {
                this.ajax(http, update);
            }
        },
        getPKey: function () {
            return gSet.pkey
        },
        httpGetParam: function (where) {
            if (where.constructor !== Object) {
                return false;
            }
            let str = '';
            $.each(where, function (k, v) {
                str += `${HTTP_CONN}${k}=${v}`
            });
            str = str.replace(HTTP_CONN, '?'); // 将第一个&替换成?
            return str;
        },
    };

    /**
     * 工具
     * @type {{print: print}}
     */
    const log = {
        /**
         * 打印Log
         * @returns {boolean}
         */
        print: function () {
            let logOn = gOptions.logOn || false;
            if (!logOn) return false;
            const tips = 'crazyTable Box';
            console.log(tips + ' | ', arguments[0], arguments[1] || '',
                arguments[2] || '', arguments[3] || '', arguments[4] || '', arguments[5] || '');
            return true;
        },
    };

    //输出接口
    exports(MOD_NAME, gHttp);
});